/**
 * KikiMami WhatsApp Web 注入脚本
 * 这个脚本会被注入到WhatsApp Web页面中，用于获取React Fiber数据
 */

// 立即执行函数，避免污染全局作用域
(function() {
    // 检查是否已经运行过此脚本
    if (window.__KIKIMAMI_FIBER_SCRIPT_INJECTED) return;
    
    // 标记脚本已注入
    window.__KIKIMAMI_FIBER_SCRIPT_INJECTED = true;
    
    // 创建一个防抖函数
    function debounce(func, wait) {
        let timeout;
        return function(...args) {
            clearTimeout(timeout);
            timeout = setTimeout(() => func.apply(this, args), wait);
        };
    }
    
    // 正在处理的聊天ID集合
    const processingChatIds = new Set();
    
    // 函数：获取Fiber数据
    function getFiberData() {
        const reactElements = document.querySelectorAll('[role="grid"] [role="listitem"]');
        
        // 用于跟踪已处理的元素数量
        let processedCount = 0;
        let elementsWithData = 0;
        
        for (let element of reactElements) {
            try {
                // 检查元素是否已经处理过
                if (element.hasAttribute('data-kiki-chat-id')) {
                    elementsWithData++;
                    continue; // 已处理过，跳过
                }
                
                // 尝试使用React Developer Tools的方式获取Fiber
                const key = Object.keys(element).find(k => k.startsWith('__reactFiber$'));
                if (!key) continue;
                
                const fiber = element[key];
                if (!fiber) continue;
                
                // 遍历fiber树查找chat对象
                let chat = null;
                let node = fiber;
                
                // 最大深度防止无限循环
                const MAX_DEPTH = 10;
                let depth = 0;
                
                while (node && !chat && depth < MAX_DEPTH) {
                    if (node.memoizedProps) {
                        // 尝试从不同的路径获取chat
                        if (node.memoizedProps.chat) {
                            chat = node.memoizedProps.chat;
                            break;
                        }
                        
                        // 尝试子路径
                        if (node.memoizedProps.children && 
                            node.memoizedProps.children.props) {
                            
                            const childrenProps = node.memoizedProps.children.props;
                            
                            if (childrenProps.chat) {
                                chat = childrenProps.chat;
                                break;
                            }
                            
                            // 递归查找
                            let current = childrenProps;
                            let maxRecursion = 5;
                            let recDepth = 0;
                            
                            while (current && !chat && recDepth < maxRecursion) {
                                if (current.chat) {
                                    chat = current.chat;
                                    break;
                                }
                                
                                if (current.children && current.children.props) {
                                    current = current.children.props;
                                } else {
                                    break;
                                }
                                
                                recDepth++;
                            }
                        }
                    }
                    
                    // 向上遍历
                    node = node.return;
                    depth++;
                }
                
                if (chat) {
                    processedCount++;
                    
                    // 设置聊天ID
                    if (chat.__x_id && chat.__x_id._serialized) {
                        const chatId = chat.__x_id._serialized;
                        element.setAttribute('data-kiki-chat-id', chatId);
                        
                        // 检查本地缓存并更新标签
                        checkCacheAndUpdateLabel(chatId, element);
                    }
                    
                    // 设置聊天标题
                    if (chat.__x_formattedTitle) {
                        element.setAttribute('data-kiki-chat-title', chat.__x_formattedTitle);
                    }
                    
                    // 添加自定义类名
                    element.classList.add('kiki-chat-item');
                }
            } catch (e) {
                console.error('处理元素时出错:', e);
            }
        }
        
        // 如果有新处理的元素，则进行一次全局标签更新
        if (processedCount > 0 && window.forceUpdateStatusLabels && typeof window.forceUpdateStatusLabels === 'function') {
            setTimeout(() => window.forceUpdateStatusLabels(), 500);
        }
    }
    
    // 防抖版本的getChatDataUnified调用
    const debouncedGetChatData = debounce(async (chatId) => {
        if (!chatId || processingChatIds.has(chatId)) return;
        
        try {
            processingChatIds.add(chatId);
            
            // 如果全局有这个函数，则调用它获取统一的聊天数据
            if (window.getChatDataUnified && typeof window.getChatDataUnified === 'function') {
                // 创建一个带超时的Promise
                const timeoutPromise = new Promise((_, reject) => {
                    setTimeout(() => reject(new Error('获取聊天数据超时')), 5000);
                });
                
                try {
                    // 使用Promise.race确保不会无限等待
                    await Promise.race([
                        window.getChatDataUnified(chatId, false),
                        timeoutPromise
                    ]);
                } catch (error) {
                    // 超时或其他错误，忽略错误继续执行
                    console.error('获取聊天数据失败:', error.message);
                }
            } else {
                // 通知扩展获取聊天数据
                window.postMessage({
                    type: 'FROM_WHATSAPP_PAGE',
                    action: 'GET_CHAT_DATA_UNIFIED',
                    chatId: chatId
                }, '*');
            }
        } finally {
            // 处理完成后移除ID
            setTimeout(() => {
                processingChatIds.delete(chatId);
            }, 500);
        }
    }, 300);
    
    // 检查缓存并更新标签
    function checkCacheAndUpdateLabel(chatId, element) {
        if (!chatId) return;
        
        // 为元素添加一个标记，表示已请求更新
        element.setAttribute('data-kiki-label-updating', 'true');
        
        // 尝试从元素获取标题
        const chatTitle = element.getAttribute('data-kiki-chat-title');
        if (chatTitle && window.kikiChatTitleMap && window.kikiChatTitleMap[chatTitle]) {
            // 如果有标题且缓存中存在，直接更新标签
            if (window.forceUpdateStatusLabels && typeof window.forceUpdateStatusLabels === 'function') {
                window.forceUpdateStatusLabels();
                return;
            }
        }
        
        // 如果没有从缓存中找到，则请求扩展进行检查
        window.postMessage({
            type: 'FROM_WHATSAPP_PAGE',
            action: 'CHECK_CACHE_AND_UPDATE_LABEL',
            chatId: chatId
        }, '*');
        
        // 同时尝试使用getChatDataUnified获取数据（使用防抖版本避免频繁调用）
        // debouncedGetChatData(chatId);
    }

    // 创建一个样式元素标记处理过的聊天项
    const style = document.createElement('style');
    style.textContent = `
        .kiki-chat-item {
            outline: 1px solid rgba(0, 128, 255, 0.2);
        }
    `;
    document.head.appendChild(style);

    // 创建观察器监听列表变化
    const observer = new MutationObserver((mutations) => {
        for (let mutation of mutations) {
            if (mutation.type === 'childList') {
                getFiberData();
                break;
            }
        }
    });

    // 定义一个函数来启动观察
    function startObserving() {
        // 尝试多种选择器找到聊天列表
        const selectors = [
            'div[aria-label="对话列表"]',
            'div[data-testid="chat-list"]',
            'div[data-tab="1"]',
            '#pane-side',
            '[role="grid"]'
        ];
        
        let chatList = null;
        for (const selector of selectors) {
            chatList = document.querySelector(selector);
            if (chatList) break;
        }
        
        if (chatList) {
            observer.observe(chatList, {
                childList: true,
                subtree: true
            });
            getFiberData(); // 立即执行一次数据获取
        } else {
            setTimeout(startObserving, 1000);
        }
    }
    
    // 添加消息监听，接收来自内容脚本的消息
    window.addEventListener('message', function(event) {
        // 确保消息来自我们的扩展
        if (event.data && event.data.type === 'FROM_KIKIMAMI_EXTENSION') {
            if (event.data.action === 'GET_FIBER_DATA') {
                getFiberData();
            } else if (event.data.action === 'UPDATE_STATUS_LABELS') {
                // 当收到更新标签的消息时，调用全局更新函数
                if (window.forceUpdateStatusLabels && typeof window.forceUpdateStatusLabels === 'function') {
                    window.forceUpdateStatusLabels();
                }
            } else if (event.data.action === 'UPDATE_STATUS_LABELS_DATA') {
                // 当收到标题状态映射数据时，更新全局变量
                if (event.data.titleMap) {
                    window.kikiChatTitleMap = event.data.titleMap;
                    
                    // 更新标签
                    if (window.forceUpdateStatusLabels && typeof window.forceUpdateStatusLabels === 'function') {
                        window.forceUpdateStatusLabels();
                    }
                }
            }
        }
    });
    
    // 开始观察
    startObserving();
    
    // 添加DOM加载完成事件处理
    window.addEventListener('load', () => {
        // 延迟执行，确保所有组件都已加载
        setTimeout(() => {
            // 执行一次初始数据获取
            getFiberData();
            
            // 通知扩展脚本页面已加载
            window.postMessage({
                type: 'FROM_WHATSAPP_PAGE',
                action: 'PAGE_LOADED'
            }, '*');
        }, 2000);
    });
    
    // 如果DOM已加载，直接执行初始化
    if (document.readyState === 'complete') {
        setTimeout(getFiberData, 1000);
    }
})(); 